%matplotlib inline

Visualización de Datos¶

Visualización de datos, es una herramienta fundamental, para todo aquel que se dedica al Análisis de Datos y es parte fundamental de la BigData que consiste en representar de manera general comprensible y medible los datos.

De wikipedia:

Los procedimientos que engloban la visualización de datos son varios:

En primer lugar es necesario analizar los datos para compendiar aquellos útiles para el conocimiento del tema y descartar los inconexos.
En segundo lugar es necesario interpretar los datos seleccionados de tal forma que sean comprensibles de forma exacta y detallada. Antes de continuar es imprescindible contrastar estos datos con otros vinculados y estudiar todos ellos para no cometer errores y saber discernir los verdaderamente significativos.
El último paso en este proceso es saber comunicar la información obtenida, de tal forma que el usuario adquiera los conocimientos necesarios para comprender correctamente los datos facilitados.

Así se puede decir que hay dos usos primarios para la visualización:

Para explorar datos.
Para comunicar datos.

En el mundo de Python, hay múltiples opciones para visualizar datos. En este cuaderno ilustraremos el uso de esas herramientas, en diversas situaciones

Matplotlib¶

Matplotlib es una biblioteca de visualización que produce gráficos de alta calidad, en una variedad de formatos impresos y entornos interactivos a través de diversas plataformas. Puede generar, histogramas, gráficos de barras,diagramas de dispersión, etc, con sólo unas pocas líneas de código. Pese a ello, hacer en Matplotlib visualización estadística sofisticada es más o menos dificil , por que a menudo requiere una gran cantidad de código repetitivo.

Matplotlib,pese a ello, destaca entre otras por sus expresiones y textos en Latex, que mejora considerablemente los gráficos en publicaciones científicas.

import warnings
warnings.filterwarnings("ignore")

Gráfico de Líneas¶

Los gráficos de líneas muestran una serie como un conjunto de puntos conectados mediante una sola línea. Los gráficos de líneas se usan para representar grandes cantidades de datos que tienen lugar durante un período continuado de tiempo.

import numpy as np
import matplotlib.mlab as mlab
from matplotlib import pyplot as plt

fechas = [1944, 1954, 1983, 1986, 1988, 1992, 1997]
gdp =[300.2, 567.3, 1075.3, 2789.4, 5965.5, 10345.5, 14897.2]

# Creamos un gráfico de linea, con fechas en el eje X, gdp en el eje Y

plt.plot(fechas, gdp, color='red', marker='o', linestyle='solid')

# Agregamos un título
plt.title("Grafico de Linea")

# Agregamos una etiqueta al eje Y 
plt.ylabel("Ganancias en $")
plt.show()

Diagrama de Barras¶

Un diagrama de barras, es una forma de representar gráficamente un conjunto de datos o valores, y está conformado por barras rectangulares de longitudes proporcionales a los valores representados. Los gráficos de barras son usados para comparar dos o más valores. Las barras pueden orientarse verticalmente u horizontalmente (Wikipedia). Un ejemplo usando Matplotlib es:

peliculas = ["Annie Hall", "Ben-Hur", "Casablanca", "Gandhi", "West Side Story"]
num_oscars = [5, 11, 3, 8, 10]

# Centremos las barras
xs = [i + 0.1 for i, _ in enumerate(peliculas)]

plt.bar(xs, num_oscars)

plt.ylabel("# de Oscars")
plt.title("Peliculas Galardonadas con el Oscar")

# Etiquetamos el eje X con el nombre de las peliculas en el centro de las barras

plt.xticks([i + 0.5 for i, _ in enumerate(peliculas)], peliculas)

plt.show()

Gráfico de varias líneas¶

Es posible tener varios gráficos con diversas características en Matplotlib.

varianza= [1,2,4,8,16,32,64,128,256]
bs_2= [256,128,64,32,16,8,4,2,1]
total_error = [x + y for x, y in zip(varianza, bs_2)]
xs = range(len(varianza))

# Podemos llamar a plt.plot varias veces para mostrar
# un grupo de figuras del mismo 'grafico'

plt.plot(xs, varianza,     'g-',  label='varianza')    
plt.plot(xs, bs_2, 'r-.', label='bias^2')      
plt.plot(xs, total_error,  'b:',  label='total error') 

# Podemos asignas lebels s ese grupo de figuras
# Contamos con una leyenda para el grafico resultante
# loc=9 significa "top center"
    
plt.legend(loc=9)
plt.xlabel("Modelo de  complexidad")
plt.title("Bias-Varianza")
plt.show()

Gráficos de dispersión¶

Los gráficos de dispersión también son conocidos como gráficos XY y su función principal es la de mostrar la relación que existe entre los valores numéricos de diferentes series de datos sobre los ejes de coordenadas XY. Veamos un ejemplo:

fr = [45, 78, 67, 89, 71, 68, 60, 74, 65]
minu = [145, 167, 132, 156, 143, 122, 114, 183, 143]
labels = ['a', 'b', 'c', 'd','e','f','g', 'h','i']
    
plt.scatter(fr, minu)

# Etiquetamos cada punto
for label, f_c, m_c in zip(labels, fr, minu):
    plt.annotate(label,
                 xy = (f_c, m_c),
                 xytext = (-5, 5),
                 textcoords='offset points')
    
    
plt.title("Minutos diarios-Numero de amigos")
plt.xlabel("Numero de amigos")
plt.ylabel("Minutos diarios en el sitio ")
plt.show()

Histogramas¶

Un histograma es una representación gráfica de una variable en forma de barras. Un ejemplo en Matplotlib, sería:

mu = 100  # media de la distribución
sigma = 15   # desviación estándar de la distribución
x = mu + sigma * np.random.randn(10000)
    
num_bins = 50
 # El histograma de la data

n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor='green', alpha=0.5)

 # agregamos una mejor 'linea de ajuste ' 
y = mlab.normpdf(bins, mu, sigma)
plt.plot(bins, y, 'r--')
plt.xlabel('Habilidades')
plt.ylabel('Probabilidad')
plt.title(r'Histograma de IQ: $\mu=100$, $\sigma=15$')

# Ajustando el espaciado en la figura
plt.subplots_adjust(left=0.15)
plt.show()

Figuras 3D¶

Para usar gráficos en 3D, necesitamos crear una instancia de la clase axes3D.

import numpy as np
from mpl_toolkits.mplot3d.axes3d import Axes3D

x = np.linspace(0, 2*np.pi, 100)
y = np.linspace(0, 2*np.pi, 100)
X,Y = np.meshgrid(x, y)

a = 0.7
valor = 2 * np.pi * 0.5

def func1(x, y):
    return 2 + a - 2 * np.cos(y) * np.cos(x) - a* np.cos(valor - 2*y)

Z = func1(X, Y).T
fig = plt.figure(figsize=(14,6))

ax = fig.add_subplot(1, 2, 1, projection='3d')
p = ax.plot_surface(X, Y, Z, rstride=4, cstride=4, linewidth=0)

# Superficie 3d en matplotlib

ax = fig.add_subplot(1, 2, 1, projection='3d')
p = ax.plot_surface(X, Y, Z, rstride=4, cstride=4, linewidth=0)

Subplots¶

fig, axes = plt.subplots(2, 2, figsize=(6, 6), sharex=True, sharey=True, squeeze=False)
x1 = np.random.randn(100)
x2 = np.random.randn(100)
axes[0, 0].set_title("No correlacionado")
axes[0, 0].scatter(x1, x2)
axes[0, 1].set_title("Correlacionado debilmente positivo")
axes[0, 1].scatter(x1, x1 + x2)
axes[1, 0].set_title("Correlacionado debilmente negativo")
axes[1, 0].scatter(x1, -x1 + x2)
axes[1, 1].set_title("Fuertemente correlacionado")
axes[1, 1].scatter(x1, x1 + 0.15 * x2)


axes[1,1].set_xlabel("x")
axes[1,0].set_xlabel("x")
axes[0,0].set_ylabel("y")
axes[1,0].set_ylabel("y")


plt.subplots_adjust(left=0.1, right=1.45, bottom=0.1, top=0.95, wspace=0.1, hspace=0.2)

Expresiones matématicas y Latex¶

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(-2*np.pi,2*np.pi,0.01)
y = np.sin(3*x)/x
y2 = np.sin(2*x)/x
y3 = np.sin(x)/x

plt.plot(x,y,color='b')
plt.plot(x,y2,color='r')
plt.plot(x,y3,color='g')

# Latex con annotate()

plt.xticks([-2*np.pi, -np.pi, 0, np.pi, 2*np.pi], [r'$-2\pi$',r'$-\pi$',r'$0$',r'$+\pi$',r'$+2\pi$'])
plt.yticks([-1,0,+1,+2,+3], [r'$-1$',r'$0$',r'$+1$',r'$+2$',r'$+3$'])

plt.annotate(r'$\lim_{x\to 0}\frac{\sin(x)}{x}= 1$', xy=[0,1],xycoords='data', 
             xytext=[30,30],fontsize=16,textcoords='offset points',arrowprops=dict(arrowstyle="->",
connectionstyle="arc3,rad=.2"))

ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
ax.spines['left'].set_position(('data',0))

Seaborn¶

Seaborn es una librería de visualización basada en matplotlib y creada para hacer visualizaciones de datos mucho más atractivos visualmente e informativos. Seaborn ofrece varias características como el construido en temas, paletas de colores, funciones y herramientas para visualizar regresiones lineales univariadad y bivariadad, matrices de datos, series temporales en estadística, etc, que nos permiten construir visualizaciones complejas. También se integra bien con Pandas.

Para una breve introducción a las ideas detrás del paquete, se puede leer las notas introductorias .

Vemos algunos ejemplos del uso de Seaborn. Empezemos por un simple gráfico:

# Las funciones seno y coseno graficadas con seaborn

import matplotlib.pyplot as plt
import seaborn as sns 
import pandas as pd
import numpy as np


sns.set()
x = np.linspace(0, 10, 1000)
plt.plot(x, np.sin(x), x, np.cos(x))
plt.show()

A menudo, en la visualización de datos estadísticos, se quiere dibujar histogramas y distribuciones conjuntas de las variables. Seaborn ofrece herramientas sencillas para que esto suceda:

# Podemos dibujar un estimado de la distribución usando Kernel Density Estimation (KDE)

data = np.random.multivariate_normal([0, 0], [[5, 2], [2, 2]], size=2000)
data = pd.DataFrame(data, columns=['x', 'y'])

for col in 'xy':
    sns.kdeplot(data[col], shade=True)
plt.show()

A veces la mejor manera de ver los datos es a través de histogramas de subconjuntos. Los FacetGrid de Seaborn hace que esto es muy simple. Vamos a echar un vistazo a algunos datos que muestra la cantidad que el personal de un restaurante reciben de propinas en base a diversos datos:

tips = sns.load_dataset('tips')
tips.head()
tips['tip_pct'] = 100 * tips['tip'] / tips['total_bill']

grid = sns.FacetGrid(tips, row="sex", col="time", margin_titles=True)
grid.map(plt.hist, "tip_pct", bins=np.linspace(0, 40, 15));
plt.show()

Al generalizar gráficos para conjuntos de datos de mayores dimensiones, se termina en pair plots. Esto es muy útil para explorar correlaciones entre los datos multidimensionales. Vemos esto con el conocido conjunto de datos iris, que enumera las medidas de pétalos y sépalos de tres especies de iris:

iris = sns.load_dataset("iris")
iris.head()
sns.pairplot(iris, hue="species", size=2.5)

plt.show()

En este ejemplo, consideramos los datos en términos de series de tiempo de la temperatura interior y exterior y el gráfico producido por Pandas, la importación de la librería de seaborn cambian la apariencia de este gráfico. El código es el siguiente:

# Un ejemplo más avanzado

df1 = pd.read_csv('te_2014.tsv', delimiter="\t", names=["time", "exterior"])
df1.time = pd.to_datetime(df1.time.values, unit="s").tz_localize('UTC').tz_convert('Europe/Stockholm')
df1 = df1.set_index("time").resample("10min")
df2 = pd.read_csv('ti_2014.tsv', delimiter="\t", names=["time", "interior"])
df2.time = pd.to_datetime(df2.time.values, unit="s").tz_localize('UTC').tz_convert('Europe/Stockholm')
df2 = df2.set_index("time").resample("10min")
df_temp = pd.concat([df1, df2], axis=1)

fig, ax = plt.subplots(1, 1, figsize=(8, 4))
df_temp.resample("D").plot(y=["exterior", "interior"], ax=ax)
fig.tight_layout()
fig.savefig("plot-seaborn.pdf")

La principal habilidad de la biblioteca Seaborn, aparte de generar gráficos vistosos, es su colección de gráficos estadísticos. Ejemplos de estos es kdeplot que muestra el KDE, una manera no paramétrica para estimar la densidad de una variable aleatoria y distplot que muestra una distribución univariada de observaciones respectivamente. Por ejemplo, las siguientes dos líneas de código producen el gráfico donde las líneas azules y verdes son el KDE calculado.

sns.distplot(df_temp.to_period("M")["exterior"]["2014-04"].dropna().values, bins=50);
sns.distplot(df_temp.to_period("M")["interior"]["2014-04"].dropna().values, bins=50);

plt.show()

Usamos la función jointplot para graficar la distribución conjunta para dos conjuntos de datos independientes.

with sns.axes_style("white"):
    sns.jointplot(df_temp.resample("H")["exterior"].values,
                  df_temp.resample("H")["interior"].values, kind="hex");

plt.show()
#plt.savefig("seaborn-jointplot.pdf")

La función kdeplot también puede operar sobre datos bidimensionales, utilizando las funciones kdeplot y jointplot mostramos la correlación de series de datos de temperatura interior y exterior, mediante un gráfico

sns.kdeplot(df_temp.resample("H")["exterior"].dropna().values,
            df_temp.resample("H")["interior"].dropna().values, shade=False);

plt.show()

ggplot¶

ggplot, es similar a Seaborn en que se construye basado en matplotlib y tiene como objetivo mejorar el atractivo de las visualizaciones matplotlib de una manera sencilla. Diverge de Seaborn en que se trata de un puerto de ggplot2 de R. Dado a esto parte de la API no es sólo Python, lo que no implica que no sea muy poderoso. Muchos ejemplos del uso de ggplot en áreas como estadística o geometría.

from matplotlib import pyplot as plt
from ggplot import *

p = ggplot(mtcars, aes('cyl'))
print (p + geom_bar())

plt.show(1)

stat_bin: binwidth defaulted to range/30.
    Use 'binwidth = x' to adjust this.

<ggplot: (-9223363280995868963)>

# Ejemplo de ggplot en funciones estadísticas

import scipy
import numpy as np
import pandas as pd
from ggplot import *
def dnorm(x, mean, var):
    return scipy.stats.norm(mean,var).pdf(x)
data = pd.DataFrame({'x':np.arange(-5,6)})
ggplot(aes(x='x'),data=data) + \
    stat_function(fun=dnorm,color="blue",
                  args={'mean':0.0,'var':0.2}) + \
    stat_function(fun=dnorm,color="red",
                  args={'mean':0.0,'var':1.0}) + \
    stat_function(fun=dnorm,color="yellow",
                  args={'mean':0.0,'var':5.0}) + \
    stat_function(fun=dnorm,color="green",
                  args={'mean':-2.0,'var':0.5})

<ggplot: (-9223363248059004423)>

Bokeh¶

Bokeh es una biblioteca de visualización interactiva de Python para el manejo de grandes conjuntos de datos que utilizan las últimas tecnologías web. Su objetivo es proporcionar una elegante construcción, concisa de nuevos gráficos al estilo de Protovis o D3. Bokeh utiliza Canvas en lugar de SVG y tiene múltiples lenguajes enlazados 'bindings' como Python, Lua, R y Julia. Estos producen un archivo JSON, el cual trabaja como una entrada para BokehJS(una librería de Java Script) que a su vez presenta los datos a los navegadores web.

from bokeh.io import output_notebook, show
from bokeh.plotting import figure
output_notebook()

# Creamos un grafico con herramientas por defecto, usando figure
p = figure(plot_width=400, plot_height=400)

# Agregamos un circulo con ciertas propiedades
p.circle([1, 2, 3, 4, 5], [6, 7, 2, 4, 5], size=15, line_color="navy", fill_color="orange", fill_alpha=0.5)

show(p) # Muestra los resultados

<bokeh.io._CommsHandle at 0x7f6a1c087cc0>

Plot y glyphs¶

De la documentación y página principal, Bokeh expone 3 interfaces a los usuarios:

bokeh.models: aplicaciones de desarrollo
bokeh.plotting : glyps
bokeh.charts: complejos gŕaficos

Se entiende por plot los recipientes que contienen los diversos objetos que comprenden la visualización final que se presenta a los usuarios. La interface bokeh.plotting proporciona figure para reunir todos los objetos necesarios y la función figure() para crear objetos Figure.
glyphs son las marcas visuales básicas que Bokeh muestra. bokeh.plotting expone muchos métodos glyphs como Figure.circle y Figure.line para mostrar una línea y un círculo. Esta apariencia visual está ligada directamente a los valores de los datos que están asociados con diversos atributos del glyps, como Line Properties, Fill Properties o Text Properties.

from bokeh.plotting import figure, output_file, show

output_file("Ejemplos")
p = figure(plot_width= 500, title = "Bokeh")
p.plot_height = 400

p.title_text_color ="green"
p.title_text_font = "times"

p.background_fill_color = "beige"
p.background_fill_alpha = 0.5

p.circle([1, 2, 3, 4, 5, 6, 7, 8, 9], [2, 5, 8, 2, 7, 3, 8, 6,1], size=10)
show(p)

<bokeh.io._CommsHandle at 0x7f6a1c0b4d30>

Ejemplo con funciones matematicas¶

import numpy as np

from bokeh.plotting import figure, show, output_file, vplot

x = np.linspace(0, 4*np.pi, 100)
y = np.cos(x) 

TOOLS = "pan,wheel_zoom,box_zoom,reset,save,box_select"

p1 = figure(title="Funciones en Bokeh", tools=TOOLS)

p1.line(x,   y, legend="cos(x)")
p1.line(x, np.abs(y), legend="|cos(x)|", color="orange")
p1.line(x, 2*y, legend="2*cos(x)", color="green")

output_file("funciones trigonometrica.html", title="Funciones en Bokeh")
show(p1)

<bokeh.io._CommsHandle at 0x7f6a1788b8d0>

# Otros ejemplo 

from bokeh.charts import Scatter, output_file, show
from bokeh.sampledata.iris import flowers as data

scatter = Scatter(data, x='petal_length', y='petal_width',
                  color='species', marker='species',
                  title='Clasificacion por especies de Iris',
                  legend=True)

output_file("Base de datos.html", title="Base de datos iris")

show(scatter)

<bokeh.io._CommsHandle at 0x7f6a17795160>

Pygal¶

Pygal se utiliza para la creación de gráficos SVG. Si se han instalado las dependencias adecuadas, también se puede guardar un archivo en formato png. Los archivos SVG son bastante útiles para hacer gráficos interactivos. Mayor información en documentación de pygal.

Para mostrar los gráficos producidos en formato png se puede instalar cairosvg via pip:

 c-lara@Lara:~$ pip install cairosvg

import pygal
import cairosvg

# http://blog.codeeval.com/codeevalblog/2014
data = [
  ["Python", 30.3],
  ["Java", 22.2],
  ["C++", 13],
  ["Ruby", 10.6],
  ["Javascript", 5.2],
  ["C#", 5],
  ["C", 4.1],
  ["PHP", 3.3],
  ["Perl", 1.6],
  ["Go", 1.5],
  ["Haskell", 1.2],
  ["Scala", 1],
  ["Objective-C", 0.4],
  ["Clojure", 0.2],
  ["Bash", 0.1],
  ["Lua", 0.04],
  ["TCL", 0.03]
]
    

# Hacemos un gráfico circular en Pygal
pie_chart = pygal.Pie()

# Agregando un título
pie_chart.title = "CodeEval: Lenguajes de Programación Populares del 2014 "

# agregamos los datos 
for label, data_points in data:
    pie_chart.add(label, data_points)

SVG(pie_chart.render())

#Enviando a un archivo svg aparte
#pie_chart.render_to_file('Ranking_Programas.svg')

# Usando cairosvg
#pie_chart.render_to_png('Ranking_Programas.png')

# Otros ejempos

from IPython.display import SVG

line_chart = pygal.Line()
line_chart.title = 'Evolucion de los navegadores web  (en %)'
line_chart.x_labels = map(str, range(2002, 2013))
line_chart.add('Firefox', [None, None,    0, 16.6,   25,   31, 36.4, 45.5, 46.3, 42.8, 37.1])
line_chart.add('Chrome',  [None, None, None, None, None, None,    0,  3.9, 10.8, 23.8, 35.3])
line_chart.add('IE',      [85.8, 84.6, 84.7, 74.5,   66, 58.6, 54.7, 44.8, 36.2, 26.6, 20.1])
line_chart.add('Otros',  [14.2, 15.4, 15.3,  8.9,    9, 10.4,  8.9,  5.8,  6.7,  6.8,  7.5])
SVG(line_chart.render())

# Correlacion

xy_chart = pygal.XY(stroke=False)
xy_chart.title = 'Correlacion'
xy_chart.add('A', [(0, 0), (.1, .2), (.3, .1), (.5, 1), (.8, .6), (1, 1.08), (1.3, 1.1), (2, 3.23), (2.43, 2)])
xy_chart.add('B', [(.1, .15), (.12, .23), (.4, .3), (.6, .4), (.21, .21), (.5, .3), (.6, .8), (.7, .8)])
xy_chart.add('C', [(.05, .01), (.13, .02), (1.5, 1.7), (1.52, 1.6), (1.8, 1.63), (1.5, 1.82), (1.7, 1.23), (2.1, 2.23), (2.3, 1.98)])
xy_chart.add('Correlacion', [(0, 0), (2.8, 2.4)], stroke=True)
SVG(xy_chart.render())

Plotly¶

plot.ly se diferencia por ser una herramienta en línea para hacer el análisis y la visualización de datos. Tiene una API que incluye a python, Excel y R. En el sitio web de esta herramientas, se pueden encontrar muchos gráficos de alta calidad e interactivos. Gracias a su excelente documentación, crear un gráfico de barras u otras operaciones con datos es relativamente simple.

Plotly se integra a la perfección con pandas y se describe aquí la instalación y funcionamiento.

# Trabajando plotly fuera de linea

from plotly import __version__
from plotly.offline import download_plotlyjs, init_notebook_mode, iplot

init_notebook_mode()

# Un ejemplo básico del uso de plotly

from plotly.graph_objs import *
import numpy as np


iplot([Box(y = np.random.randn(50), showlegend=False) for i in range(45)], show_link=False)

# Graficos de dispersion con plotly

import plotly.plotly as py
import plotly.graph_objs as go

# Creaando variablea aleatorias con numpy
import numpy as np

N = 1000
random_x = np.random.randn(N)
random_y = np.random.randn(N)

# Creaamos la traza
traza = go.Scatter(
    x = random_x,
    y = random_y,
    mode = 'markers'
)

data = [traza]

# Plot and embed in ipython notebook!
py.iplot(data, filename='dispersion')

Se puede usar Plotly, de manera que el archivo html, se pueda guardar de manera local y se pueda abrir con un navegador web, como en el primer ejemplo. Podemos ver un resumen de comandos de Plotly, aquí.

# Ejemplo sobre el uso de plotly  y archivos .csv (Manual)

import pandas as pd
import numpy as np
import plotly.plotly as py
import plotly.graph_objs as go

# Importamos  data csv
df = pd.read_csv('apple.csv')
df.head()

trace = go.Scatter(
                  x = df['AAPL_x'], y = df['AAPL_y'],
                  name='Precio de acciones  (en USD)'
                  )
layout = go.Layout(
                  title='Precio de las acciones de  Apple  (2014)',
                  plot_bgcolor='rgb(230, 230,230)', 
                  showlegend=True
                  )
fig = go.Figure(data=[trace], layout=layout)

py.iplot(fig, filename='Precios de Apple')

Plotly proporciona un servicio de alojamiento web para gráficos. Crea una cuenta gratis para empezar. Los gráficos se guardan dentro de su cuenta en línea y tu te encargas de controlar la privacidad.

mpld3¶

mpld3 es un proyecto de visualización interactivo que usa matplotlib y la librería de JavaScript D3js. El resultado es una API simple para la exportación de sus gráficos a código HTML que pueden ser utilizados dentro del navegador, dentro de las páginas web estándar, blogs o herramientas como Jupyter.

Dentro de la distribución Anaconda, la instalación es la siguiente:

c-lara@Lara:~$ conda install -c https://conda.anaconda.org/jacksongs mpld3

Algunos ejemplos se pueden encontrar en el blog de Jake Vanderplas.

Lecturas importantes:¶

Una lectura interesante acerca de este tema es el artículo de Ignasi Alcalde Visualización de datos, retos y mitos.
Recursos para comprender la Visualización de Datos.
Visualización usando Bokeh de Python.
Uso de seaborn en Visualización de datos.
Colocando gráficos en tu página web con Pygal.
Creando gráficos con python y plotly.

	AAPL_x	AAPL_y
0	2014-01-02	77.445395
1	2014-01-03	77.045575
2	2014-01-06	74.896972
3	2014-01-07	75.856461
4	2014-01-08	75.091947